/**

Copyright (C) SYSTAP, LLC DBA Blazegraph 2006-2016.  All rights reserved.

Contact:
     SYSTAP, LLC DBA Blazegraph
     2501 Calvert ST NW #106
     Washington, DC 20008
     licenses@blazegraph.com

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/
/*
 * Created on Aug 25, 2010
 */

package com.bigdata.service;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.util.UUID;

import com.bigdata.bop.BOp;
import com.bigdata.io.DirectBufferPool;
import com.bigdata.io.DirectBufferPoolAllocator;
import com.bigdata.io.DirectBufferPoolAllocator.IAllocation;

/**
 * This class manages a pool of direct {@link ByteBuffer}s. The application can
 * create which are exposed for retrieval by remote services.
 * 
 * @author <a href="mailto:thompsonbry@users.sourceforge.net">Bryan Thompson</a>
 * @version $Id: ManagedResourceService.java 3515 2010-09-08 13:16:30Z
 *          thompsonbry $
 * 
 * @todo Harmonize the constructors with the base class (and perhaps simplify)
 *       and add a constructor argument for the maximum #of buffers which may be
 *       allocated from the pool or leave this to the annotated {@link BOp}s or
 *       to logic managing resource utilization during query evaluation? E.g.,
 *       breaking a query if it would demand too many resources given the
 *       concurrent query demand or forcing the query to block until sufficient
 *       resources are available?
 */
abstract public class ManagedResourceService extends ResourceService {

    private final DirectBufferPoolAllocator allocator;

    /**
     * The object used to make, resolve, and release allocations against a
     * {@link DirectBufferPool}.
     */
    public DirectBufferPoolAllocator getAllocator() {
       
        return allocator;
        
    }
    
    /**
     * Create and start the service.
     * 
     * @param addr
     *            The IP address and port at which the service will accept
     *            connections. The port MAY be zero to use an ephemeral port.
     * @param requestServicePoolSize
     *            The size of the thread pool that will handle requests. When
     *            ZERO (0) a cached thread pool will be used with no specific
     *            size limit.
     * 
     * @throws IOException
     */
    public ManagedResourceService(final InetSocketAddress addr,
            final int requestServicePoolSize) throws IOException {

        super(addr, requestServicePoolSize);

        this.allocator = new DirectBufferPoolAllocator(
                DirectBufferPool.INSTANCE);

    }
    
    @Override
    synchronized public void shutdown() {
        super.shutdown();
        allocator.close();
    }

    @Override
    synchronized public void shutdownNow() {
        super.shutdownNow();
        allocator.close();
    }

    /**
     * {@inheritDoc}
     * 
     * @todo An allocation can be concurrently released if a query terminates.
     *       Make sure that we interrupt any transfer in progress for the
     *       allocation when the allocation is released since there is nothing
     *       to prevent the same direct {@link ByteBuffer} from being assigned
     *       to a new allocation context and new allocations made against it
     *       concurrent with any ongoing attempt to read the data from that
     *       allocation.
     */
    @Override
    protected ByteBuffer getBuffer(final UUID uuid) throws Exception {
        final IAllocation allocation = allocator.getAllocation(uuid);
        if (allocation == null)
            return null;
        return allocation.getSlice();
    }

}
